home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Demos / OOFILE / Buildable, limited OOFILE / c-tree headers / ctfunp.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-12  |  44.2 KB  |  1,139 lines  |  [TEXT/CWIE]
  1. /*
  2.  *    This program is the CONFIDENTIAL and PROPRIETARY property 
  3.  *    of FairCom(R) Corporation. Any unauthorized use, reproduction or
  4.  *    transfer of this computer program is strictly prohibited.
  5.  *
  6.  *      Copyright (c) 1984 - 1994 FairCom Corporation.
  7.  *    This is an unpublished work, and is subject to limited distribution and
  8.  *    restricted disclosure only. ALL RIGHTS RESERVED.
  9.  *
  10.  *            RESTRICTED RIGHTS LEGEND
  11.  *    Use, duplication, or disclosure by the Government is subject to
  12.  *    restrictions set forth in subparagraph (c)(1)(ii) of the Rights in
  13.  *     Technical Data and Computer Software clause at DFARS 252.227-7013.
  14.  *    FairCom Corporation, 4006 West Broadway, Columbia, MO 65203.
  15.  *
  16.  *    c-tree PLUS(tm)    Version 6.4
  17.  *            Release B
  18.  *            October 19, 1994
  19.  */
  20.  
  21. #ifndef ctFUNPH
  22. #define ctFUNPH
  23.  
  24. #ifndef ctPARMH
  25. #include "ctparm.h"
  26. #endif
  27.  
  28. #ifdef DllLoadDS
  29. #define _lds_   DllLoadDS
  30. #else
  31. #define _lds_
  32. #endif
  33.  
  34. #ifdef CTBOUND
  35.  
  36. #ifndef ctBONDH
  37. #include "ctbond.h"
  38. #endif
  39.  
  40. #else
  41.  
  42. #ifndef ctCOMMH
  43. #include "ctcomm.h"
  44. #endif
  45.  
  46. #endif
  47.  
  48. #ifdef ctLOCLIB
  49. #include "ctlocf.h"
  50. #endif
  51. #include "ctdecl.h"
  52.  
  53. #ifdef PROTOTYPE
  54.  
  55. extern  VOID         ctclrcon(COUNT datno);
  56. extern  VOID         ctclrlockon(VOID );
  57. extern  COUNT        iretrec(COUNT datno,LONG recbyt,NINT chgent);
  58. #ifdef DBG9477
  59. extern  NINT         log9477(pCTFILE knum,LONG node,NINT locale);
  60. #endif
  61. #ifdef UNIFRMAT
  62. extern  NINT         ctconvert1(pTEXT tp,pConvMap map,pConvBlk blk,VRLEN len,UTEXT dbyte,NINT cnv_mode);
  63. extern  VOID         rev_fhdr(pTEXT tp);
  64. extern  VOID         rev_shdr(pTEXT tp);
  65. extern  VOID         rev_rhdr(pTEXT tp);
  66. extern  VOID         rev_thdr(pTEXT tp);
  67. extern  VOID         rev_nhdr(pTEXT tp);
  68. extern  VOID         rev_vhdr(pTEXT tp);
  69. #endif
  70. extern  VOID         ctsetkeypos(COUNT keyno,LONG node,COUNT elm,pVOID kp,COUNT keylen);
  71. extern  COUNT        rblsavres(COUNT keyno,pTEXT idxname,pTEXT fileword);
  72. extern  COUNT        ctrvrng(COUNT hghno);
  73. extern  VOID         ctuutbl(ctRECPT pntr,COUNT datno);
  74. #ifdef FPUTFGET
  75. #ifdef LOCK_TEST
  76. extern  COUNT        chkutbl(COUNT datno,COUNT lokmod,ctRECPT pntr);
  77. #endif
  78. #endif
  79. extern  pTEXT        rbgetbuf(VRLEN bufsiz);
  80. extern  NINT         ctuhash(COUNT filno,LONG pntr);
  81. #ifdef FASTCOMP
  82. extern  COUNT        CTCOMP(pTEXT val1,pTEXT val2,COUNT keylen);
  83. extern  UCOUNT       CTCOMPU(pTEXT np, pTEXT op, UCOUNT smlen);
  84. #endif
  85. extern  VRLEN        igetifil(COUNT datno,LONG buflen,pVOID bufptr,pLONG pdf);
  86. #ifdef MULTITRD
  87. extern NINT ctmemmon(VOID );
  88. extern  NINT         ctunblkq(NINT qindex);
  89. extern  NINT         ctblkbsy(pSEMA sema);
  90. extern  pVOID        ctgvallc(NINT sOWNR,NINT alloc);
  91. extern  NINT         ctUserAlive(NINT chkcomm);
  92. #endif
  93. #ifndef ctrt_filcmp
  94. extern  NINT         ctrt_filcmp(pTEXT n1,pTEXT n2);
  95. #endif
  96. #ifdef ctSQL
  97. extern ctCONV  LONG  ctDECL sqllock(COUNT lokmod);
  98. extern  COUNT        ADDRECs(COUNT datno,pVOID recptr,NINT srlmod);
  99. extern  COUNT        ADDVRECs(COUNT datno,pVOID recptr,VRLEN varlen,NINT srlmod);
  100. extern NINT blksrlint(NINT,NINT);
  101. #endif
  102. #ifndef nd_digPROTO
  103. #define nd_digPROTO
  104. extern  COUNT        nd_dig(pTEXT digbuf,COUNT digno);
  105. extern  VOID         nd_digenc(pTEXT digbuf,COUNT digno,COUNT val);
  106. #endif
  107. extern  pTEXT        uTFRMKEY(COUNT keyno,pVOID    tarptr);
  108. extern  pTEXT        i2TFRMKEY(COUNT keyno,pVOID tarptr,LONG pntr,NINT usepntr);
  109. extern  VOID         ctsysint(pCTINIT1 pconfig);
  110. extern  VOID         ctclnhdr(pCTFILE ctnum);
  111. extern  COUNT        chkvfin(COUNT datno,COUNT k,COUNT slen);
  112. extern  VRLEN ctDECL ctcdelm(pTEXT tp,NINT ch,VRLEN len);
  113. #ifndef CTBOUND
  114. extern  pMTEXT       recommbuf(VRLEN len,VRLEN olen);
  115. extern ctCONV  COUNT ctDECL COMMBUF(pULONG memchg,LONG newslct,VRLEN bufsiz,pLQMSG lqp);
  116. #ifdef ctNOCOMMGLOBALS
  117. extern  pFarCmdPtr   ctCommLoad(pTEXT dllname, ppVOID lcommGbls);
  118. extern  VOID         ctCommUnload(pFarCmdPtr ctMEM *, ppVOID);
  119. #else
  120. extern  pFarCmdPtr   ctCommLoad(pTEXT dllname);
  121. #endif
  122. #endif
  123. extern  VOID         ctlnhdr(pCTFILE ctnum);
  124. extern  COUNT        ishtifil(COUNT datno,NINT cloze);
  125. extern  pTREBUF      ctintnod(pTREBUF buf,pCTFILE knum,LONG node);
  126. extern  COUNT        ctgetsec(COUNT filno,pTEXT uid,pTEXT gid,pTEXT pwd,pLONG pm);
  127. extern  NINT         ctkw(pTEXT kw,pTEXT *kw_lst,NINT nkw);
  128. extern  pCOUNT       ctlfsegget(COUNT keyno,COUNT numseg,ppCOUNT paltseq);
  129. extern  VOID         ctlfsegput(COUNT keyno,COUNT segno,COUNT pos,COUNT len,COUNT mod);
  130. extern  VOID         ctmakid(pLONG id,pCTFILE ctnum);
  131. extern  pTEXT        ctrtnam(pTEXT sp);
  132. extern  COUNT        ctspcopn(NINT op_code,pCTFILE ctnum);
  133. extern  VOID         ctuftbl(COUNT ufil,pCTFILE ctnum,NINT uncond);
  134. extern  COUNT        ctgetseginfo(COUNT keyno,COUNT segno,COUNT mode);
  135. extern ctCONV  LONG  ctDECL ctdidx(COUNT idx,pTEXT names);
  136. extern  VOID         setifil(pIFIL ifilptr,pIFILBLK piblk,pTEXT dataextn,pTEXT indxextn,pTEXT fileword,LONG permmask,pTEXT groupid);
  137. extern ctCONV  COUNT ctDECL iTMPNAME(pTEXT bufptr,VRLEN bufsiz);
  138. extern  COUNT        ctkeytrn(pCTFILE knum);
  139. extern  COUNT        ctultbl(ctRECPT pntr,COUNT datno,COUNT lokmod,COUNT ismflg);
  140. extern  ctRECPT      seqikey(COUNT keyno,pTEXT idxval,COUNT mode);
  141. extern  COUNT        putdodas(COUNT datno,pDATOBJ doda,UCOUNT numfld);
  142. extern  COUNT        putdodan(COUNT datno,pDATOBJ doda,UCOUNT numfld);
  143. #ifdef ctSRVR
  144. extern  COUNT        ctaddusr(COUNT datno,pVOID recptr);
  145. extern  COUNT        ctchgusr(pTEXT bufptr);
  146. #endif
  147. extern  VOID         mbfreel(pVOID objptr);
  148. extern  VOID         mbfrenl(ppVOID pobjptr);
  149. #ifdef ctHFREE
  150. extern  VOID         cthfree(pVOID p);
  151. #endif
  152. extern  COUNT        igetdefblk(COUNT filno,pDEFDEF defp,COUNT srvrmode);
  153. extern  COUNT        ctsetseq(pCTFILE knum,pCOUNT aq);
  154. #ifdef MULTITRD
  155. extern  VOID         ctsetnmda(pLOGBLK logb,pLQMSG logq,COUNT fils);
  156. extern  VOID         ctsetuginfo(pLQMSG lqp);
  157. extern  COUNT        ctsetres(pCTFILE ctnum,COUNT ufilno,COUNT filmod,pCRESEC pcresec);
  158. #else
  159. extern  COUNT        ctsetres(pCTFILE ctnum,COUNT filmod);
  160. #endif
  161. extern  VOID         ctfusrclr(COUNT mode,NINT sOWNR);
  162. extern  VOID         ctfilok(VOID );
  163. extern  VOID         ctiflnam(pIFILBLK piblk,pTEXT nambuf,NINT mode,pTEXT ext);
  164. #ifdef NEWIFIL
  165. extern  pTEXT        makifil(pTEXT buf,pTEXT dext,pTEXT iext,LONG defwrd,UINT rlen,pUINT plen,NINT mode);
  166. #else
  167. extern  pTEXT        makifil(pTEXT buf,pTEXT dext,pTEXT iext);
  168. #endif
  169. #ifndef CTBOUND
  170. extern  COUNT        ctgetseg(COUNT keyno,pTEXT bufptr,VRLEN size);
  171. extern  COUNT        ctgetmap(COUNT datno,pTEXT bufptr,VRLEN size);
  172. #endif
  173. extern ctCONV  COUNT ctDECL OPNIFILz(pIFILBLK pifilblk);
  174. extern ctCONV  COUNT ctDECL PUTIFILz(pIFILBLK pifilblk);
  175. extern ctCONV  COUNT ctDECL CREIFILz(pIFILBLK pifilblk);
  176. extern ctCONV  COUNT ctDECL PRMIIDXz(pIFILBLK pifilblk);
  177. extern ctCONV  COUNT ctDECL TMPIIDXz(pIFILBLK pifilblk);
  178. extern ctCONV  COUNT ctDECL RBLIFILz(pIFILBLK pifilblk);
  179. extern ctCONV  COUNT ctDECL CMPIFILz(pIFILBLK pifilblk);
  180. extern         COUNT CLIFILz(pIFILBLK pifilblk);
  181. extern         COUNT DELIFILz(pIFILBLK pifilblk);
  182. extern  COUNT        iintree(pCTINIT1 pconfig);
  183. extern ctCONV  COUNT ctDECL TRANRDY(VOID );
  184. extern  UINT         ctadjadr(UINT alignment,UINT fkind,pVOID fadr);
  185. extern  NINT         ctadjfld(UINT fkind,pTEXT fadr);
  186. extern  pVOID        ctrdef(COUNT datno,pUINT plen,NINT type);
  187. extern  COUNT        getrhdr(pCTFILE dnum,LONG pntr,pRESHDR presblk,NINT namode);
  188. extern  COUNT        putrhdr(pCTFILE dnum,LONG pntr,pRESHDR presblk);
  189. extern ctCONV  COUNT ctDECL SETDEFBLK(COUNT datno,pDEFDEF defp);
  190. extern ctCONV  COUNT ctDECL GETDEFBLK(COUNT datno,pDEFDEF defp);
  191. extern  pTEXT        cptifil(pIFIL ifilp,pTEXT buf,pVRLEN plen,pTEXT dext, pTEXT iext);
  192. extern  COUNT        ctrstdef(COUNT datno,pIFIL ip,pTEXT dext,pTEXT iext);
  193. #ifndef cpybig
  194. extern  pTEXT        bigadr(pTEXT tp,VRLEN offset);
  195. extern  VOID         cpybig(pTEXT dp,pTEXT sp,VRLEN n);
  196. #endif
  197. #ifdef MULTITRD
  198. extern  COUNT        getintr(FILE *ifd,pCOUNT pbufs,pCOUNT pkeys,pCOUNT psecs,pCOUNT pdats,COUNT userprof,pLQMSG lqp,COUNT files);
  199. #else
  200. extern  COUNT        getintr(FILE *ifd,pCOUNT pbufs,pCOUNT pkeys,pCOUNT psecs,pCOUNT pdats,COUNT userprof);
  201. #endif
  202. extern  LONG         ctfsize(pCTFILE ctnum);
  203. extern  COUNT        ctrcvlog(pTEXT msg,COUNT err);
  204. extern  pTEXT        ctdate(LONG pt);
  205. #ifdef CTSUPER
  206. extern  COUNT        cthstopn(COUNT ufilno,pTEXT filnam,COUNT filmod);
  207. extern  COUNT        ctcresi(COUNT datno,COUNT filmod);
  208. #ifdef MULTITRD
  209. extern  COUNT        cresmem(COUNT hstno,COUNT memno,pTEXT afilnam,pTEXT sfilnam, UCOUNT len,COUNT keytyp,COUNT keydup,COUNT memb,COUNT filmod,pCRESEC pcresec);
  210. #else
  211. extern  COUNT        cresmem(COUNT hstno,COUNT memno,pTEXT afilnam,pTEXT sfilnam, UCOUNT len,COUNT keytyp,COUNT keydup,COUNT memb,COUNT filmod);
  212. #endif
  213. extern  NINT         ctsname(pTEXT fn,pTEXT sfn);
  214. #endif
  215. extern  LONG         ctdhupd(LONG ,NINT ,pCTFILE ,COUNT );
  216. extern  pLSTITM      ctgetlst(NINT listype);
  217. extern  VOID         ctputlst(pLSTITM lp,NINT listype);
  218. #ifndef ctsfill
  219. extern  VOID         ctsfill(pVOID dp,NINT ch,UINT n);
  220. #endif
  221. #ifndef ctbfill
  222. extern  VOID         ctbfill(pVOID dp,NINT ch,VRLEN n);
  223. #endif
  224. extern  VOID         ctsetlst(VRLEN nodepage,VRLEN datapage,UCOUNT nidx,UCOUNT ndat);
  225. extern  pTEXT        ctgetmem(VRLEN iosize);
  226. extern  VOID         ctputmem(pTEXT loc);
  227. extern  VOID         ctputmemn(ppVOID ploc);
  228. #ifndef CTBOUND
  229. extern  VOID         ctbldlcl(NINT sOWNR,COUNT filno,pCTFILE ctnum);
  230. #endif
  231. extern  VOID         ctcatend(NINT mode,NINT loc,COUNT    fil,LONG pos);
  232. extern  NINT         ctcfill(pTEXT tp,NINT ch,VRLEN len);
  233. extern  LONG         ctpstk(pTEXT sp);
  234. extern  VOID         ctrstk(VOID );
  235. extern  VOID _lds_   ctdefer(LONG );
  236. extern  LONG         cttime(VOID );
  237. #ifndef ctsysnap
  238. extern  NINT         ctsysnap(LONG);
  239. #endif
  240. extern  COUNT        iaddkey(COUNT keyno,pTEXT target,LONG recbyt,COUNT typadd);
  241. extern  COUNT        adroot(pCTFILE knum,LONG lpntr,LONG rpntr,pTEXT idxval);
  242. extern  pTREBUF      newnod(PFAST pCTFILE knum,pLONG pnode,COUNT virgin);
  243. extern  COUNT        ctwrtbuf(pDATBUF db);
  244. extern  NINT         ctflush(pCTFILE ctnum,NINT keep);
  245. extern  NINT         ctblock(NINT op_code,pCTFILE ctnum,LONG recbyt,pTEXT recptr,VRLEN len,pLONG pretsiz);
  246. extern  pTEXT        mballc(NINT numobj,UINT sizobj);
  247. #ifndef mblllc
  248. extern  pTEXT        mblllc(NINT numobj,VRLEN sizobj);
  249. #endif
  250. extern  VOID         mbfren(ppVOID pobjptr);
  251. extern  VOID         mbfree(pVOID objptr);
  252. #ifdef MTMEMRY
  253. extern  LONG         arep(COUNT mode);
  254. #endif
  255. extern  COUNT        uerr(COUNT err_no);
  256. extern  VOID         terr(COUNT err_no);
  257. extern  VOID         revobj(pTEXT tp,NINT len);
  258. extern  VOID         revbyt(pTEXT tp,NINT len);
  259. extern  VOID         revwrd(pTEXT tp,NINT len);
  260. extern  VOID         ctchknum(NINT opmode);
  261. extern  VOID         ctinrnum(NINT opmode,RNDFILE retval);
  262. extern  VOID         cpylod(ppTEXT hdp,pVOID sp,UINT n);
  263. #ifndef cpylodl
  264. extern  VOID         cpylodl(ppTEXT hdp,pVOID sp,VRLEN n);
  265. #endif
  266. extern  VOID         cpynbuf(pTEXT dp,pTEXT sp,UINT n);
  267. extern  VOID         cpysrc(pVOID dp,ppTEXT hsp,UINT n);
  268. #ifndef cpysrcl
  269. extern  VOID         cpysrcl(pVOID dp,ppTEXT hsp,VRLEN n);
  270. #endif
  271. extern  NINT         ctcomexc(NINT mode,LONG tran,ppCOMLST hcmlist);
  272. extern  VOID         ctlowhsh(pBHL pbhl,pBHL anchor,COUNT end);
  273. extern  COUNT        ctfixdel(pCTFILE ctnum,pCTFILE knum);
  274. extern  COUNT        ctio(COUNT op_code,pCTFILE ctnum,LONG recbyt,pVOID bufadr,VRLEN iosize);
  275. extern  NINT         ctrelhdr(pCTFILE ctnum);
  276. extern  NINT         ctrelbuf(NINT bad,pTREBUF bp);
  277. extern  UCOUNT       diffimag(pTEXT newptr,UCOUNT newlen,pTEXT oldptr,UCOUNT oldlen);
  278. extern  COUNT        compar(pTEXT val1,pTEXT val2,pCTFILE knum);
  279. extern  ppTEXT       chkcopy(VOID );
  280. extern  pTEXT        ctputk(COUNT keyno,pTEXT recptr,LONG pntr,NINT mode,VRLEN datlen);
  281. extern  COUNT        tstrec(PFAST pCTFILE dnum,LONG recbyt);
  282. extern  COUNT        prthdr(COUNT filno);
  283. extern  COUNT        prtnod(COUNT filno,LONG nodex);
  284. extern  COUNT        chkidx(COUNT filno);
  285. extern  COUNT        idelchk(COUNT keyno,pTEXT target,LONG recbyt,COUNT blkmode);
  286. extern  NINT         ctdnode(pTEXT sp);
  287. extern  VOID         ctdnodestop(VOID);
  288. extern  VOID         ctqnode(pCTFILE knum,LONG node,COUNT mode);
  289. extern  VOID         ctrmvexc(pTREBUF buffer,UCOUNT elm);
  290. extern  COUNT        ctdelkey(PFAST pCTFILE knum,pTEXT idxval,LONG pntr,COUNT blkmode);
  291. extern  COUNT        rtnode(pTREBUF buffer,LONG node,pCTFILE knum);
  292. extern  COUNT        ckflmp(COUNT filno);
  293. extern  pFUSR        ctrvfl(NINT sOWNR,COUNT afil);
  294. extern  COUNT        ctdwnfil(NINT sOWNR,COUNT filno,COUNT cloze,COUNT ufil,NINT direct);
  295. extern  COUNT        chkopn(pTEXT fn,NINT mode);
  296. extern  NINT         chkredf(COUNT ufil,pCTFILE ctnum);
  297. extern  COUNT        getctf(VOID );
  298. extern  COUNT        getctm(COUNT blocks,pCTFILE btnum);
  299. extern  VOID         retctf(COUNT filno);
  300. extern  COUNT        ctfree(NINT mode);
  301. extern  NINT         ctstpsrv(VOID );
  302. extern  NINT         ctrelusr(NINT owner);
  303. extern  LONG         extfil(pCTFILE ctnum,VRLEN rsize,VRLEN align);
  304. extern  pCTFILE      tstfnm(COUNT filno);
  305. extern  COUNT        vtclose(VOID );
  306. extern  pFILE         ctgetstream(pTEXT sn,pTEXT mode,NINT repeat);
  307. extern  VOID         inrfil(PFAST pCTFILE ctnum,NINT mode,NINT direct);
  308. extern  COUNT        tstupd(PFAST pCTFILE ctnum);
  309. extern  COUNT        redhdr(PFAST pCTFILE ctnum);
  310. extern  COUNT        filhdr(PFAST pCTFILE ctnum);
  311. extern  COUNT        wrthdr(PFAST pCTFILE ctnum);
  312. extern  COUNT        iopnfil(COUNT filno,pTEXT filnam,COUNT filmod);
  313. extern  COUNT        wrtnod(PFAST pTREBUF buffer,COUNT mode,pNINT pusrn);
  314. extern  COUNT        iclsfil(COUNT filno,COUNT filmod);
  315. extern ctCONV  COUNT ctDECL reset_cur(PFAST COUNT keyno,ctRECPT pntr,pTEXT recptr);
  316. extern  LONG         chkism(COUNT datno);
  317. extern  VOID         setsrlpos(COUNT datno,pTEXT recptr);
  318. extern  VOID         iundo(COUNT op_code,COUNT datno,COUNT i,LONG pntr,LONG old_pntr);
  319. extern  COUNT        addikey(COUNT datno,pTEXT recptr,LONG pntr,VRLEN datlen);
  320. extern  COUNT        rwtikey(COUNT datno,pTEXT recptr,LONG pntr,LONG old_pntr,VRLEN datlen);
  321. extern  COUNT        delikey(COUNT datno,LONG pntr);
  322. extern  VOID         ctfisam(NINT sOWNR,COUNT fils);
  323. #ifdef MULTITRD
  324. extern  NINT         ctiisam(pLOGBLK plog,pLQMSG lqp);
  325. #else
  326. extern  NINT         ctiisam(COUNT bufs,COUNT fils,COUNT sect,COUNT dbufs,COUNT userprof);
  327. #endif
  328. extern  COUNT        setudat(FILE *ifd,COUNT datno);
  329. extern  COUNT        setukey(FILE *ifd,COUNT keyno,COUNT keytyp);
  330. extern  pCTFILE      tstifnm(COUNT filno);
  331. extern  COUNT        ierr(COUNT err_cod,COUNT file_no);
  332. extern  COUNT        addlok(LONG pntr,COUNT datno);
  333. extern  TEXT         ucase(TEXT t);
  334. extern  COUNT        ctasskey(COUNT keyno,pTEXT recptr,PFAST pTEXT txt,VRLEN datlen);
  335. extern  COUNT        getdatr(FILE *ifd,pCOUNT pdatno,pTEXT pname,pUCOUNT pdatln,pCOUNT pdkeys,pUCOUNT pxtsiz,pCOUNT pfilmd);
  336. extern  COUNT        getidxr(FILE *ifd,COUNT datno,COUNT dfilemd,COUNT j,pCOUNT pkeyno,pTEXT pname,pCOUNT pklen,pCOUNT pktyp,pCOUNT pdflg,pCOUNT pnmem,pUCOUNT pxtsiz,pCOUNT pfilmd);
  337. extern  COUNT        getambr(FILE *ifd,COUNT datno,COUNT dfilemd,COUNT j,COUNT keyno,pCOUNT pklen,pCOUNT pktyp,pCOUNT pdflg);
  338. extern  VOID         ctsetlog(pCTFILE ctnum,COUNT filmod);
  339. extern  COUNT        icredat(COUNT datno,pTEXT filnam,pTEXT sfilnam,UCOUNT datlen,UCOUNT xtdsiz,COUNT filmod,pCTFILE hnum,LONG hp);
  340. extern  NINT         ctidxcap(pCTFILE ,COUNT ,COUNT ,COUNT ,COUNT );
  341. extern  COUNT        icreidx(COUNT keyno,pTEXT filnam,pTEXT sfilnam,COUNT keylen,COUNT keytyp,COUNT keydup,COUNT nomemb,UCOUNT xtdsiz,COUNT filmod,pCTFILE hnum,LONG hp);
  342. extern  pCTFILE      icremem(COUNT keyno,COUNT keylen,COUNT keytyp,COUNT keydup,COUNT membno);
  343. extern  UCOUNT       ctelmexc(pTREBUF buffer,COUNT elm,pULONG ptran);
  344. extern  COUNT        ctexcp(pTREBUF buffer,COUNT elm,COUNT adflag,LONG tran);
  345. #ifdef MULTITRD
  346. extern  NINT         ctgetkbf(NINT sOWNR,COUNT keyno,COUNT keylen);
  347. #else
  348. extern  NINT         ctgetkbf(pCTFILE knum,COUNT keylen);
  349. #endif
  350. extern  COUNT        nodser(PFAST pTREBUF buffer,pTEXT idxval,TEXT stratg,COUNT adflag);
  351. extern  pBHL         cthshbuf(LONG node,COUNT list);
  352. extern  VOID         ctputhsh(pTREBUF buf,COUNT list,COUNT end);
  353. extern  VOID         ctclrhsh(pTREBUF buf);
  354. extern  pTREBUF      ctgetnod(NINT lokind,LONG node,pCTFILE knum);
  355. extern  pTREBUF      lrubuf(COUNT mode,LONG node,pCTFILE knum);
  356. extern  VOID         ctnodcap(pTREBUF buffer,pCTFILE knum,NINT lf);
  357. #ifdef FPUTFGET
  358. extern  LONG         gtroot(PFAST pCTFILE knum);
  359. #endif
  360. extern  pTEXT        valpnt(PFAST pTREBUF buffer,PFAST COUNT elm);
  361. extern  pTEXT        hghpnt(PFAST pTREBUF buffer);
  362. extern  LONG         nodpnt(PFAST pTREBUF buffer,PFAST COUNT elm);
  363. extern  LONG         drnpnt(PFAST pTREBUF buffer,PFAST COUNT elm);
  364. extern  pTEXT        expval(PFAST pTREBUF bp,COUNT n);
  365. extern  COUNT        nodctl(pCTFILE ctnum,LONG node,pTREBUF buffer,pVHDR pvrhdr);
  366. extern  COUNT        ct_strip(PFAST pCTFILE knum,LONG logpos);
  367. extern  COUNT        iloadkey(COUNT keyno,pTEXT target,LONG recbyt,COUNT typadd);
  368. extern  VOID         newleaf(PFAST pTREBUF bp,PFAST pCTFILE kp);
  369. extern  VOID         nonleaf(PFAST pTREBUF bp,PFAST pCTFILE kp);
  370. extern  COUNT        rerr(COUNT err_cod,COUNT file_no);
  371. extern  COUNT        yesno(VOID );
  372. extern  COUNT        vcparm(pUCOUNT pp,UCOUNT rv,pTEXT txt);
  373. extern  COUNT        vtparm(pTEXT pp,UCOUNT rv,pTEXT txt);
  374. extern  COUNT        prnprm(UCOUNT hv,UCOUNT rv,pTEXT txt);
  375. extern  COUNT        RBLDATX(COUNT datno,pTEXT datnam,COUNT datlen,UCOUNT xtdsiz,COUNT filemd,pTEXT fileword);
  376. extern  COUNT        RBLIDX(COUNT datno,pTEXT datname,COUNT keyno,pTEXT fileword);
  377. extern  COUNT        RBLMEM(COUNT datno,pTEXT datname,COUNT keyno,COUNT membno,pTEXT fileword);
  378. extern  VOID         ctupdkey(pCTFILE knum);
  379. extern  COUNT        scndat(pCTFILE dnum);
  380. extern  VOID         pshlst(pRECLOK plok,pCTFILE ctnum,NINT bin);
  381. extern  COUNT        ctaddblk(ppBLKLST blkh,ppBLKLST blkt,NINT sOWNR,pRECLOK cp,pVOID cb,COUNT loktyp);
  382. extern  NINT         ctremblk(ppBLKLST blkh,ppBLKLST blkt,pRECLOK cp,pCTFILE ctnum);
  383. extern  COUNT        cts_lok(NINT usrn,COUNT filno,COUNT loktyp,COUNT mode,LONG recbyt,COUNT dlkfre);
  384. extern  COUNT        LOCK(LONG node,pCTFILE knum);
  385. extern  NINT         iunlock(COUNT usr,LONG pos,pCTFILE ctnum);
  386. extern  COUNT        UNLOCK(LONG node,pCTFILE knum);
  387. extern  COUNT        DLOCK(LONG recbyt,pCTFILE dnum,NINT lokmod);
  388. #ifdef MULTITRD
  389. extern  COUNT        RLOCK(LONG recbyt,pCTFILE dnum,NINT lokmod);
  390. #else
  391. extern  COUNT        RLOCK(LONG recbyt,pCTFILE dnum);
  392. #endif
  393. extern  COUNT        UDLOCK(LONG recbyt,pCTFILE dnum);
  394. extern  LONG         ieqlkey(COUNT keyno,pTEXT target);
  395. extern  LONG         igtekey(COUNT keyno,pTEXT target,pTEXT idxval);
  396. extern  LONG         ilstkey(COUNT keyno,pTEXT idxval);
  397. extern  LONG         nxtikey(COUNT keyno,pTEXT idxval);
  398. extern  LONG         prvikey(COUNT keyno,pTEXT idxval);
  399. extern  LONG         igtkey(PFAST COUNT keyno,pTEXT target,pTEXT idxval);
  400. extern  COUNT        ctscnexc(pTREBUF buffer,COUNT elm);
  401. extern  COUNT        ctrevexc(pTREBUF buffer,COUNT elm);
  402. extern  LONG         fndkey(PFAST pCTFILE knum,pTEXT target,TEXT stratg,pTEXT idxval);
  403. extern  COUNT        chkset(COUNT keyno,LONG recpos,pTEXT recptr);
  404. extern  COUNT        setset(COUNT keyno,pTEXT target,PFAST COUNT siglen);
  405. extern  COUNT        igetaltseq(COUNT keyno,pCOUNT altseq,COUNT srvrmode);
  406. extern  COUNT        hdrupd(pCTFILE knum,LONG chgnum);
  407. extern  COUNT        ctmrkexc(pTREBUF buffer,COUNT elm,UCOUNT adflag,NINT shflag,LONG trbf);
  408. extern  VOID         ctrstexc(pCTFILE ctnum,pTREBUF buf);
  409. extern  LONG         ctabtexc(NINT mode,COUNT keyno,LONG node,LONG tran,pLONG ptran,NINT num);
  410. extern  COUNT        ctabtnod(pCTFILE ctnum);
  411. extern  COUNT        ctclup(NINT sOWNR,pTREBUF buffer,NINT tranmode,NINT shrink);
  412. extern  COUNT        putnod(PFAST pTREBUF buf,PFAST COUNT nodsiz,NINT hash,NINT tryulk);
  413. extern  VOID         prpdup(pTEXT ip,pCTFILE knum,pLONG pntrp);
  414. extern  pTREBUF      movrgt(pTEXT idxval,PFAST pCTFILE knum,PFAST pTREBUF buffer,COUNT adflag);
  415. extern  VOID         shfrgt(PFAST COUNT n,pTREBUF bp,UCOUNT strbyt);
  416. extern  COUNT        ideladd(pCTFILE knum,pTEXT td,LONG rd,pTEXT ta,LONG ra,COUNT cf);
  417. extern  VOID         insexp(PFAST pTREBUF bp,pTEXT ip,LONG pntr);
  418. extern  COUNT        delexp(PFAST pTREBUF bp);
  419. extern  LONG         inewvrec(pCTFILE vnum,COUNT ufil,VRLEN varlen,NINT lnkflg,NINT cntflg);
  420. extern  COUNT        iretvrec(COUNT datno,COUNT ufil,LONG recbyt);
  421. extern  COUNT        getvhdr(PFAST pCTFILE vnum,LONG pntr,pVHDR phdr);
  422. extern  COUNT        putvhdr(PFAST pCTFILE vnum,LONG pntr,pVHDR phdr);
  423. extern  COUNT        frmlkey(pCTFILE ctnum,pTEXT pkeybuf,pTEXT plen,LONG pntr);
  424. extern  COUNT        chkvhdr(PFAST pVHDR phdr);
  425. extern  VRLEN        prprdv(COUNT datno,LONG recbyt,pTEXT recptr,VRLEN bufsiz);
  426. extern  LONG         chkvsm(COUNT datno);
  427. extern  COUNT        ctVERIFY(COUNT keyno,pLONG pcnt);
  428. extern  NINT         link_verify(pCTFILE knum,LONG node,LONG pnode,NINT lev,COUNT pelm,COUNT pnkv);
  429. extern  NINT         leaf_verify(pCTFILE knum,pLONG pcnt);
  430. extern  NINT         leaf_extra(COUNT keyno,COUNT datno);
  431. extern  COUNT        ctseek(RNDFILE cfd,LONG recbyt);
  432. extern  NINT         ctswitch(pCTFILE ctnum);
  433. extern  COUNT        ictio(COUNT op_code,pCTFILE ctnum,LONG recbyt,pVOID bufadr,VRLEN iosize,pLONG pretsiz);
  434. extern  COUNT        ctsysio(COUNT op_code,RNDFILE cfd,LONG recbyt,pVOID bufadr,VRLEN iosize,pLONG pretsiz);
  435. extern  COUNT        dltfil(pTEXT filnam);
  436. extern  COUNT        cnvdltfil(pTEXT fn);
  437. extern  COUNT        renfil(pTEXT oldnam,pTEXT newnam);
  438. extern  NINT         cttcre(pNINT ,NINT (*)(VOID ),UINT ,NLONG );
  439. extern  NINT         ctqcre(NINT qindex,NINT qsize);
  440. extern  NINT         ctqwrt(NINT qindex,pVOID qmsgptr,NINT qmsglen);
  441. extern  NINT         ctqred(NINT qindex,pVOID qmsgptr,LONG timeout);
  442. extern NINT ctqchk(pDQMSG);
  443. extern  NINT         ctmqwrt(NINT mode,pTEXT msg,COUNT rc);
  444. extern  VOID         cttsksetup(VOID );
  445. extern  NINT _lds_   ctsemclr(pSEMA sema,NINT own);
  446. extern  NINT         ctsemwat(pSEMA sema,LONG wait,NINT own);
  447. extern  NINT _lds_   ctsemrqs(pSEMA sema,LONG wait,NINT own);
  448. #ifdef ctCREATE_SEMA
  449. extern  NINT _lds_   ctsemcls(pSEMA sema);
  450. #endif
  451. #ifdef ctSEMBLK
  452. extern  NINT _lds_   ctblkclr(pSEMA sema,NINT own);
  453. extern  NINT         ctblkwat(pSEMA sema,LONG wait,NINT own);
  454. extern  NINT _lds_   ctblkrqs(pSEMA sema,LONG wait,NINT own);
  455. #endif
  456. #ifdef ctSEMCOM
  457. #ifndef CTBOUND
  458. extern  NINT         ctcomclr(pLQMSG ,NINT , NINT);
  459. extern  NINT         ctcomrqs(pLQMSG ,NINT , LONG ,NINT);
  460. extern  NINT         ctcomwat(pLQMSG ,NINT , LONG ,NINT);
  461. #endif
  462. #endif
  463. extern  NINT         ctlclose(pCTFILE ctnum,COUNT clmode,NINT cleanup);
  464. extern  COUNT        mbclos(pCTFILE ctnum,COUNT clmode);
  465. #ifdef ctMIRROR
  466. extern  NINT         ctswtmir(pCTFILE ctnum,NINT err);
  467. extern  COUNT        ctmirhdr(pCTFILE ctnum);
  468. extern  NINT         ctmname(pTEXT fn,ppTEXT mp);
  469. extern  NINT         ctmalert(pTEXT pn,pTEXT mn,NINT err);
  470. extern  COUNT        ctmopen(pCTFILE ctnum,COUNT filmod,NINT cleanup);
  471. extern  RNDFILE      ctopen(pCTFILE ctnum,COUNT filmod);
  472. extern  COUNT        ctmcreate(pCTFILE ctnum,NINT idxflag,COUNT filmod);
  473. #ifdef MULTITRD
  474. extern  VOID         ctfrcmir(pCTFILE ctnum,NINT sOWNR);
  475. #else
  476. extern  VOID         ctfrcmir(pCTFILE ctnum);
  477. #endif
  478. #endif
  479. extern  RNDFILE      mbopen(pCTFILE ctnum,COUNT opmode);
  480. extern  RNDFILE      mbcrat(pCTFILE ctnum,COUNT opmode);
  481. extern  COUNT        mbsave(pCTFILE ctnum);
  482. #ifndef ctsave
  483. extern  COUNT        ctsave(pCTFILE ctnum);
  484. #endif
  485. extern  VOID         flushdos(COUNT datno);
  486. extern  COUNT        filrng(COUNT filno,COUNT nm,COUNT filmod);
  487. extern  COUNT        setimap(COUNT i,pIFIL ip,COUNT keyno,COUNT exsidx);
  488. #ifdef BIGCHECK
  489. extern  NINT         CTCFILL(pTEXT ch, NINT tp, UINT smlen);
  490. #endif
  491.  
  492. #ifdef MULTITRD
  493. extern  COUNT        INTREEz(pLOGBLK plog,pLQMSG lqp);
  494. extern  COUNT        INTISAMz(pLOGBLK plog,pLQMSG lqp);
  495. extern  COUNT        CREISAMz(pISAMBLK pisam,pLQMSG lqp);
  496. extern  COUNT        OPNISAMz(pISAMBLK pisam,pLQMSG lqp);
  497.  
  498. extern  NINT         ctcnvfn(pTEXT fn);
  499. extern  VOID         cttsus(LONG tid);
  500. extern  NINT         ctloglog(NINT sOWNR,pTEXT userid,NINT mode);
  501. extern  NINT         ctclrsrvr(pLQMSG lqp);
  502. extern  NINT         ctqcls(NINT qindex);
  503. extern  VOID         stopctsrvr(VOID);
  504. extern  NINT         PIFlush(NINT sOWNR,VRLEN iosize);
  505. extern  FarCmdPtr   *commCmds[MAXCOMMP];
  506. extern  VOID         ctsetnmda(pLOGBLK logb,pLQMSG logq,COUNT fils);
  507. extern  COUNT        ctugfil(NINT t);
  508. extern  COUNT        ctsetsec(pCTFILE ctnum,pCRESEC pcresec,COUNT filno,LONG respos,pTEXT userid);
  509. extern  COUNT        ctchksec(pCTFILE ctnum,pTEXT fileword,COUNT filno,COUNT filmod,NINT admflg);
  510. extern  VOID         ctsetuginfo(pLQMSG lqp);
  511. extern  NINT         ctismem(VRLEN iosize);
  512. extern  NINT         ctmemavl(NINT sOWNR,VRLEN iosize,NINT list,NINT syslmt,NINT usrlmt,NINT mattr,NINT force);
  513. extern  NINT         blkcmtint(NINT sOWNR,NINT mode,COUNT lokmod);
  514. #ifndef CTBOUND
  515. extern  NINT         VDP(COUNT func,pTEXT mp,pVAB pvab,pLQMSG lqp);
  516. #endif
  517. extern  VOID         setcommbuf(pULONG memchg,pLQMSG lqp);
  518. extern  VOID         ctdec(pTEXT dp,pTEXT sp,NINT len,LONG k1,LONG k2);
  519. extern  NINT         ctblksrvr(pLQMSG  lqp);
  520. extern  COUNT        srvrwait(NINT sOWNR,pLQMSG l,LONG delay,UCOUNT noMem);
  521. extern  VOID         initctsrvr(VOID);
  522. extern  VOID         srvrcopyright(pTEXT legend);
  523. extern  VOID         srvrflashmsg(pTEXT legend);
  524. extern  VOID         ctenc(pTEXT dp,pTEXT sp,NINT len,LONG k1,LONG k2);
  525. extern  VOID         startctsrvr(VOID);
  526. extern  NINT         ctclrclnt(pLQMSG lqp);
  527. extern NINT ctkilblk(NINT);
  528.  
  529. #ifdef ___FNPglobals___
  530. extern  Thread_     *makeThread(ProcPtr thread,int32 size,int32 refcon,int32 priority,int32 freq,int32 narg,VOID *parm);
  531. extern  byte        *memory(int32 nbr, int32 size);
  532. extern  VOID         delayDefer(LONG len);
  533. extern  VOID        *threadInit(VOID *term);
  534. extern  VOID         killThread(Thread_ *t);
  535. extern  int32        getThdTime(VOID);
  536. extern  Thread_     *myThread(VOID);
  537. extern  VOID         sleepThread(Thread_ *t, int32 max);
  538. extern  VOID         DEFER(VOID);
  539. #endif /* ___FNPglobals___ */
  540. #endif /* MULTITRD */
  541.  
  542. extern  VOID         ctidxfrsh(COUNT keyno);
  543. extern COUNT chkidxhdr(NINT,pIIDX,COUNT,COUNT);
  544.  
  545. #ifdef TRANPROC
  546. #ifdef SYNC_LOG
  547. extern COUNT ctsync(pCTFILE    ctnum,NINT mode);
  548. #endif
  549. #endif
  550.  
  551. #ifdef ctSQL
  552.  
  553. NINT FlushLRU( pVOID, pVOID );
  554. VOID login_auth( pVOID, pUTEXT );
  555. VOID SetSQLTransactionMode( pVOID, COUNT );
  556.  
  557. #endif  /*  ctSQL  */
  558.  
  559. #if 0
  560.  
  561. static  VOID         setver(pCTFILE ctnum,NINT bins);
  562. static  pLSTHED      ctgethed(pLSTANC la,UCOUNT ls,NINT listype);
  563. static  VOID         ctputhed(pLSTANC la,pLSTHED lh,NINT listype);
  564. static  pTREBUF      lodnod(pCTFILE knum,pLONG pnode);
  565. static  pTEXT        iTFRMKEY(COUNT keyno,pTEXT tarptr,LONG pntr);
  566. static  pTEXT        padrec(pTEXT txt,pTEXT recpos,UCOUNT slen,TEXT pbyte,TEXT dbyte);
  567. static  pTEXT        padrec2(pTEXT txt,pTEXT recpos,UCOUNT slen,LONG fl4,TEXT pbyte,pTEXT tstpos);
  568. static  COUNT        nxtbat(UCOUNT mode);
  569. static  COUNT        intred(pCTFILE ,LONG ,pTEXT ,VRLEN ,pLONG );
  570. static  pTEXT        getrb(VRLEN rz);
  571. static  COUNT        frsbat(NINT batfun);
  572. static  NINT         ifrebat(VOID );
  573. static  COUNT        delbat(VOID );
  574. static  NINT         chkbtrq(pCTFILE ctnum,pTEXT result);
  575. static  NINT         chkbtlk(COUNT filno,LONG pntr);
  576. static  COUNT        chkbtvf(COUNT keyno,LONG pntr,pTEXT result,pNINT psetlsp);
  577. static  VOID         ctfctlblk(ppLSTITM pbase,NINT ctyp,NINT btyp);
  578. static  NINT         cntlist(ppLSTITM lpp,COUNT num,NINT ctyp,NINT btyp);
  579. static  NINT         avlspc(pCTFILE vnum,pTEXT tp,VRLEN varlen);
  580. static  pTEXT        ctgstk(UINT stksiz,LONG parm);
  581. static  VOID         ctsplexc(pCTFILE knum,pTREBUF old,pTREBUF newone,pTEXT lp,COUNT total,COUNT ipos,COUNT last,NINT adflag);
  582. static  COUNT        insert(pTREBUF buffer,pCTFILE knum,pTEXT idxval,LONG pntr,COUNT typadd,LONG oldroot,NINT adflag);
  583. static  VOID         ctputdsh(pDATBUF buf,NINT list,COUNT end);
  584. static  pDATBUF      ctgetbuf(COUNT fn,LONG bb,COUNT op_code,pVRLEN plen);
  585. static  VOID         clrbuf(pCTFILE ctnum,LONG recbyt,VRLEN wb);
  586. static  UCOUNT       ctdash(COUNT fn,UINT bb);
  587. static  pBHL         ctdshbuf(COUNT fn,LONG bb,NINT list);
  588. static  COUNT        srklok(NINT sOWNR,LONG node,pCTFILE knum);
  589. static  COUNT        delpbm(COUNT lev);
  590. static  COUNT        updprd(LONG delnod,LONG node,pCTFILE knum,COUNT npoNINT,LONG snode);
  591. static  COUNT        delupl(LONG snode,pCTFILE knum);
  592. static  COUNT        binsrc(COUNT keyno,COUNT i,COUNT flag,pTEXT idxval);
  593. static  COUNT        ismred(COUNT datno,COUNT keyno,LONG pntr,pTEXT recptr);
  594. static  COUNT        reset_phy(pCTFILE ctnum,LONG pntr,pTEXT recptr,COUNT mode,COUNT ufil);
  595. static  COUNT        seqrec(COUNT mode,COUNT filno,pTEXT recptr);
  596. static  COUNT        bndrec(COUNT mode,COUNT filno,pTEXT recptr);
  597. static  pTEXT        ctgetmp(COUNT keyno);
  598. static  COUNT        tstinm(COUNT filno,COUNT nmem);
  599. static  COUNT        setmap(COUNT datno,COUNT dfilemd,COUNT j,COUNT keyno,COUNT klen,COUNT ksegs,COUNT dflg,COUNT nTEXT,COUNT nulflg,FILE *ifd);
  600. static  UCOUNT       cthash(UINT node);
  601. static  COUNT        rednod(PFAST pTREBUF buffer,pTREBUF chkbuf,LONG node,pCTFILE knum);
  602. static  pTREBUF      lodins(PFAST pTREBUF buffer,pTEXT idxval,LONG recbyt,PFAST pCTFILE knum);
  603. static  pTREBUF      skim(pCTFILE knum);
  604. static  COUNT        chkpar(pCTFILE knum,COUNT kl,COUNT kt,COUNT df,COUNT nm,UCOUNT xt,pNINT fhdr);
  605. static  COUNT        getdt(COUNT keyno,COUNT datno,pTEXT datname,pLONG keyrej,pTEXT fileword);
  606. static  COUNT        tstmode(COUNT mode,ppRECLOK pcp,NINT direct);
  607. static  NINT         ctdlok(COUNT sOWNR,COUNT blocker);
  608. static  COUNT        dellst(COUNT usrn,COUNT filno,LONG recbyt);
  609. static  LONG         ser(PFAST COUNT keyno,pTEXT target,pTEXT idxval,TEXT stratg);
  610. static  COUNT        ctanyexc(pTREBUF buf);
  611. static  VOID         shflft(PFAST COUNT n,pTREBUF bp,UCOUNT strbyt);
  612. #ifdef MULTITRD
  613. static  NINT         dupopen(pCTFILE ctnum,NINT acflag,NINT shflag,RNDFILE zerofd);
  614. #endif
  615.  
  616. #endif  /*  if 0 (temporary)  */
  617.  
  618. #else /* PROTOTYPE */
  619.  
  620. extern  VOID         ctclrcon();
  621. extern  VOID         ctclrlockon();
  622. extern  COUNT        iretrec();
  623. #ifdef UNIFRMAT
  624. extern  NINT         ctconvert1();
  625. extern  VOID         rev_fhdr();
  626. extern  VOID         rev_shdr();
  627. extern  VOID         rev_rhdr();
  628. extern  VOID         rev_thdr();
  629. extern  VOID         rev_nhdr();
  630. extern  VOID         rev_vhdr();
  631. #endif
  632. extern  VOID         ctsetkeypos();
  633. extern  COUNT        rblsavres();
  634. extern  COUNT        ctrvrng();
  635. extern  VOID         ctuutbl();
  636. #ifdef FPUTFGET
  637. #ifdef LOCK_TEST
  638. extern  COUNT        chkutbl();
  639. #endif
  640. #endif
  641. extern  pTEXT        rbgetbuf();
  642. static  VOID         setver();
  643. extern  NINT         ctuhash();
  644. #ifdef FASTCOMP
  645. extern  COUNT        CTCOMP();
  646. extern  UCOUNT       CTCOMPU();
  647. #endif
  648. static  pLSTHED      ctgethed();
  649. static  VOID         ctputhed();
  650. extern  VRLEN        igetifil();
  651. #ifdef MULTITRD
  652. extern NINT ctmemmon();
  653. extern  NINT         ctunblkq();
  654. extern  NINT         ctblkbsy();
  655. extern  pVOID        ctgvallc();
  656. extern  NINT         ctUserAlive();
  657. #endif
  658. #ifndef ctrt_filcmp
  659. extern  NINT         ctrt_filcmp();
  660. #endif
  661. #ifdef ctSQL
  662. extern ctCONV  LONG  ctDECL sqllock();
  663. extern  COUNT        ADDRECs();
  664. extern  COUNT        ADDVRECs();
  665. extern NINT blksrlint();
  666. #endif
  667. static  pTREBUF      lodnod();
  668. #ifndef nd_digPROTO
  669. #define nd_digPROTO
  670. extern  COUNT        nd_dig();
  671. extern  VOID         nd_digenc();
  672. #endif
  673. extern  pTEXT        uTFRMKEY();
  674. static  pTEXT        iTFRMKEY();
  675. extern  pTEXT        i2TFRMKEY();
  676. extern  VOID         ctsysint();
  677. extern  VOID         ctclnhdr();
  678. extern  COUNT        chkvfin();
  679. extern  VRLEN ctDECL ctcdelm();
  680. #ifndef CTBOUND
  681. extern  pMTEXT       recommbuf();
  682. extern ctCONV  COUNT ctDECL COMMBUF();
  683. extern  pFarCmdPtr   ctCommLoad();
  684. #ifdef ctNOCOMMGLOBALS
  685. extern  VOID         ctCommUnload();
  686. #endif
  687. #endif
  688. extern  VOID         ctlnhdr();
  689. extern  COUNT        ishtifil();
  690. extern  pTREBUF      ctintnod();
  691. extern  COUNT        ctgetsec();
  692. extern  NINT         ctkw();
  693. extern  pCOUNT       ctlfsegget();
  694. extern  VOID         ctlfsegput();
  695. extern  VOID         ctmakid();
  696. extern  pTEXT        ctrtnam();
  697. extern  COUNT        ctspcopn();
  698. extern  VOID         ctuftbl();
  699. extern  COUNT        ctgetseginfo();
  700. extern ctCONV  LONG  ctDECL ctdidx();
  701. extern  VOID         setifil();
  702. extern ctCONV  COUNT ctDECL iTMPNAME();
  703. extern  COUNT        ctkeytrn();
  704. extern  COUNT        ctultbl();
  705. extern  ctRECPT      seqikey();
  706. extern  COUNT        putdodas();
  707. extern  COUNT        putdodan();
  708. static  pTEXT        padrec();
  709. static  pTEXT        padrec2();
  710. static  COUNT        nxtbat();
  711. #ifdef ctSRVR
  712. extern  COUNT        ctaddusr();
  713. extern  COUNT        ctchgusr();
  714. #endif
  715. extern  VOID         mbfreel();
  716. extern  VOID         mbfrenl();
  717. static  COUNT        intred();
  718. extern  COUNT        igetdefblk();
  719. static  pTEXT        getrb();
  720. static  COUNT        frsbat();
  721. static  NINT         ifrebat();
  722. static  COUNT        delbat();
  723. extern  COUNT        ctsetseq();
  724. extern  VOID         ctsetnmda();
  725. extern  VOID         ctsetuginfo();
  726. extern  COUNT        ctsetres();
  727. extern  VOID         ctfusrclr();
  728. extern  VOID         ctfilok();
  729. static  NINT         chkbtrq();
  730. static  NINT         chkbtlk();
  731. static  COUNT        chkbtvf();
  732. extern  VOID         ctiflnam();
  733. static  VOID         ctfctlblk();
  734. static  NINT         cntlist();
  735. extern  pTEXT        makifil();
  736. #ifndef CTBOUND
  737. extern  COUNT        ctgetseg();
  738. extern  COUNT        ctgetmap();
  739. #endif
  740. extern ctCONV  COUNT ctDECL OPNIFILz();
  741. extern ctCONV  COUNT ctDECL PUTIFILz();
  742. extern ctCONV  COUNT ctDECL CREIFILz();
  743. extern ctCONV  COUNT ctDECL PRMIIDXz();
  744. extern ctCONV  COUNT ctDECL TMPIIDXz();
  745. extern ctCONV  COUNT ctDECL RBLIFILz();
  746. extern ctCONV  COUNT ctDECL CMPIFILz();
  747. extern         COUNT CLIFILz();
  748. extern         COUNT DELIFILz();
  749. extern  COUNT        iintree();
  750. extern ctCONV  COUNT ctDECL TRANRDY();
  751. extern  UINT         ctadjadr();
  752. extern  NINT         ctadjfld();
  753. extern  pVOID        ctrdef();
  754. extern  COUNT        getrhdr();
  755. extern  COUNT        putrhdr();
  756. extern  COUNT        SETDEFBLK();
  757. extern  COUNT        GETDEFBLK();
  758. extern  pTEXT        cptifil();
  759. extern  COUNT        ctrstdef();
  760. #ifndef cpybig
  761. extern  pTEXT        bigadr();
  762. extern  VOID         cpybig();
  763. #endif
  764. extern  LONG         ctfsize();
  765. static  NINT         avlspc();
  766. extern  COUNT        ctrcvlog();
  767. extern  pTEXT        ctdate();
  768. #ifdef CTSUPER
  769. extern  COUNT        cthstopn();
  770. extern  COUNT        ctcresi();
  771. extern  COUNT        cresmem();
  772. extern  NINT         ctsname();
  773. #endif
  774. extern  LONG         ctdhupd();
  775. extern  pLSTITM      ctgetlst();
  776. extern  VOID         ctputlst();
  777. #ifndef ctsfill
  778. extern  VOID         ctsfill();
  779. #endif
  780. #ifndef ctbfill
  781. extern  VOID         ctbfill();
  782. #endif
  783. extern  VOID         ctsetlst();
  784. extern  pTEXT        ctgetmem();
  785. extern  VOID         ctputmem();
  786. extern  VOID         ctputmemn();
  787. #ifndef CTBOUND
  788. extern  VOID         ctbldlcl();
  789. #endif
  790. extern  VOID         ctcatend();
  791. extern  NINT         ctcfill();
  792. static  pTEXT        ctgstk();
  793. extern  LONG         ctpstk();
  794. extern  VOID         ctrstk();
  795. extern  VOID _lds_   ctdefer();
  796. extern  LONG         cttime();
  797. #ifndef ctsysnap
  798. extern  NINT         ctsysnap();
  799. #endif
  800. extern  COUNT        iaddkey();
  801. static  VOID         ctsplexc();
  802. static  COUNT        insert();
  803. extern  COUNT        adroot();
  804. extern  pTREBUF      newnod();
  805. extern  COUNT        ctwrtbuf();
  806. static  VOID         ctputdsh();
  807. static  pDATBUF      ctgetbuf();
  808. extern  NINT         ctflush();
  809. static  VOID         clrbuf();
  810. extern  NINT         ctblock();
  811. static  UCOUNT       ctdash();
  812. static  pBHL         ctdshbuf();
  813. extern  pTEXT        mballc();
  814. #ifndef mblllc
  815. extern  pTEXT        mblllc();
  816. #endif
  817. extern  VOID         mbfren();
  818. extern  VOID         mbfree();
  819. #ifdef MTMEMRY
  820. extern  LONG         arep();
  821. #endif
  822. extern  COUNT        uerr();
  823. extern  VOID         terr();
  824. extern  VOID         revobj();
  825. extern  VOID         revbyt();
  826. extern  VOID         revwrd();
  827. extern  VOID         ctchknum();
  828. extern  VOID         ctinrnum();
  829. extern  VOID         cpylod();
  830. #ifndef cpylodl
  831. extern  VOID         cpylodl();
  832. #endif
  833. extern  VOID         cpynbuf();
  834. extern  VOID         cpysrc();
  835. #ifndef cpysrcl
  836. extern  VOID         cpysrcl();
  837. #endif
  838. extern  NINT         ctcomexc();
  839. extern  VOID         ctlowhsh();
  840. extern  COUNT        ctfixdel();
  841. extern  COUNT        ctio();
  842. extern  NINT         ctrelhdr();
  843. extern  NINT         ctrelbuf();
  844. extern  UCOUNT       diffimag();
  845. extern  COUNT        compar();
  846. extern  ppTEXT       chkcopy();
  847. extern  pTEXT        ctputk();
  848. extern  COUNT        tstrec();
  849. extern  COUNT        prthdr();
  850. extern  COUNT        prtnod();
  851. extern  COUNT        chkidx();
  852. extern  COUNT        idelchk();
  853. extern  NINT         ctdnode();
  854. extern  VOID         ctdnodestop();
  855. extern  VOID         ctqnode();
  856. extern  VOID         ctrmvexc();
  857. static  COUNT        srklok();
  858. extern  COUNT        ctdelkey();
  859. extern  COUNT        rtnode();
  860. static  COUNT        delpbm();
  861. static  COUNT        updprd();
  862. static  COUNT        delupl();
  863. static  COUNT        binsrc();
  864. extern  COUNT        ckflmp();
  865. extern  pFUSR        ctrvfl();
  866. extern  COUNT        ctdwnfil();
  867. extern  COUNT        chkopn();
  868. extern  NINT         chkredf();
  869. extern  COUNT        getctf();
  870. extern  COUNT        getctm();
  871. extern  VOID         retctf();
  872. extern  COUNT        ctfree();
  873. extern  NINT         ctstpsrv();
  874. extern  NINT         ctrelusr();
  875. extern  COUNT        iNINTree();
  876. extern  LONG         extfil();
  877. extern  pCTFILE      tstfnm();
  878. extern  COUNT        vtclose();
  879. extern  pFILE         ctgetstream();
  880. extern  VOID         inrfil();
  881. extern  COUNT        tstupd();
  882. extern  COUNT        redhdr();
  883. extern  COUNT        filhdr();
  884. extern  COUNT        wrthdr();
  885. extern  COUNT        iopnfil();
  886. extern  COUNT        wrtnod();
  887. extern  COUNT        iclsfil();
  888. static  COUNT        ismred();
  889. extern ctCONV  COUNT ctDECL reset_cur();
  890. static  COUNT        reset_phy();
  891. extern  LONG         chkism();
  892. static  COUNT        seqrec();
  893. static  COUNT        bndrec();
  894. static  pTEXT        ctgetmp();
  895. extern  VOID         setsrlpos();
  896. extern  VOID         iundo();
  897. extern  COUNT        addikey();
  898. extern  COUNT        rwtikey();
  899. extern  COUNT        delikey();
  900. extern  VOID         ctfisam();
  901. extern  NINT         ctiisam();
  902. extern  COUNT        setudat();
  903. extern  COUNT        setukey();
  904. extern  pCTFILE      tstifnm();
  905. extern  COUNT        ierr();
  906. extern  COUNT        addlok();
  907. extern  TEXT         ucase();
  908. extern  COUNT        ctasskey();
  909. static  COUNT        tstinm();
  910. extern  COUNT        getNINTr();
  911. extern  COUNT        getdatr();
  912. static  COUNT        setmap();
  913. extern  COUNT        getidxr();
  914. extern  COUNT        getambr();
  915. extern  VOID         ctsetlog();
  916. extern  COUNT        icredat();
  917. extern  NINT         ctidxcap();
  918. extern  COUNT        icreidx();
  919. extern  pCTFILE      icremem();
  920. extern  UCOUNT       ctelmexc();
  921. extern  COUNT        ctexcp();
  922. #ifdef MULTITRD
  923. extern  NINT         ctgetkbf();
  924. #else
  925. extern  NINT         ctgetkbf();
  926. #endif
  927. extern  COUNT        nodser();
  928. static  UCOUNT       cthash();
  929. extern  pBHL         cthshbuf();
  930. extern  VOID         ctputhsh();
  931. extern  VOID         ctclrhsh();
  932. extern  pTREBUF      ctgetnod();
  933. extern  pTREBUF      lrubuf();
  934. extern  VOID         ctnodcap();
  935. static  COUNT        rednod();
  936. #ifdef FPUTFGET
  937. extern  LONG         gtroot();
  938. #endif
  939. extern  pTEXT        valpnt();
  940. extern  pTEXT        hghpnt();
  941. extern  LONG         nodpnt();
  942. extern  LONG         drnpnt();
  943. extern  pTEXT        expval();
  944. static  pTREBUF      lodins();
  945. extern  COUNT        nodctl();
  946. extern  COUNT        ct_strip();
  947. static  pTREBUF      skim();
  948. extern  COUNT        iloadkey();
  949. extern  VOID         newleaf();
  950. extern  VOID         nonleaf();
  951. extern  COUNT        rerr();
  952. extern  COUNT        yesno();
  953. extern  COUNT        vcparm();
  954. extern  COUNT        vtparm();
  955. extern  COUNT        prnprm();
  956. extern  COUNT        RBLDATX();
  957. extern  COUNT        RBLIDX();
  958. extern  COUNT        RBLMEM();
  959. static  COUNT        chkpar();
  960. extern  VOID         ctupdkey();
  961. static  COUNT        getdt();
  962. extern  COUNT        scndat();
  963. extern  VOID         pshlst();
  964. static  COUNT        tstmode();
  965. static  NINT         ctdlok();
  966. extern  COUNT        ctaddblk();
  967. extern  NINT         ctremblk();
  968. extern  COUNT        cts_lok();
  969. static  COUNT        dellst();
  970. extern  COUNT        LOCK();
  971. extern  NINT         iunlock();
  972. extern  COUNT        UNLOCK();
  973. extern  COUNT        DLOCK();
  974. extern  COUNT        RLOCK();
  975. extern  COUNT        UDLOCK();
  976. extern  LONG         ieqlkey();
  977. static  LONG         ser();
  978. extern  LONG         igtekey();
  979. extern  LONG         ilstkey();
  980. extern  LONG         nxtikey();
  981. extern  LONG         prvikey();
  982. extern  LONG         igtkey();
  983. extern  COUNT        ctscnexc();
  984. extern  COUNT        ctrevexc();
  985. extern  LONG         fndkey();
  986. extern  COUNT        chkset();
  987. extern  COUNT        setset();
  988. extern  COUNT        igetaltseq();
  989. extern  COUNT        hdrupd();
  990. extern  COUNT        ctmrkexc();
  991. extern  VOID         ctrstexc();
  992. extern  LONG         ctabtexc();
  993. extern  COUNT        ctabtnod();
  994. extern  COUNT        ctclup();
  995. static  COUNT        ctanyexc();
  996. extern  COUNT        putnod();
  997. extern  VOID         prpdup();
  998. extern  pTREBUF      movrgt();
  999. extern  VOID         shfrgt();
  1000. static  VOID         shflft();
  1001. extern  COUNT        ideladd();
  1002. extern  VOID         insexp();
  1003. extern  COUNT        delexp();
  1004. extern  LONG         inewvrec();
  1005. extern  COUNT        iretvrec();
  1006. extern  COUNT        getvhdr();
  1007. extern  COUNT        putvhdr();
  1008. extern  COUNT        frmlkey();
  1009. extern  COUNT        chkvhdr();
  1010. extern  VRLEN        prprdv();
  1011. extern  LONG         chkvsm();
  1012. extern  COUNT        ctVERIFY();
  1013. extern  NINT         link_verify();
  1014. extern  NINT         leaf_verify();
  1015. extern  NINT         leaf_extra();
  1016. extern  COUNT        ctseek();
  1017. extern  NINT         ctswitch();
  1018. extern  COUNT        ictio();
  1019. extern  COUNT        ctsysio();
  1020. extern  COUNT        dltfil();
  1021. extern  COUNT        cnvdltfil();
  1022. extern  COUNT        renfil();
  1023. extern  NINT         cttcre();
  1024. extern  NINT         ctqcre();
  1025. extern  NINT         ctqwrt();
  1026. extern  NINT         ctqred();
  1027. extern NINT ctqchk();
  1028. extern  NINT         ctmqwrt();
  1029. extern  VOID         cttsksetup();
  1030. #ifdef ctCREATE_SEMA
  1031. extern  NINT _lds_   ctsemcls();
  1032. #endif
  1033. extern  NINT _lds_   ctsemrqs();
  1034. extern  NINT _lds_   ctsemclr();
  1035. extern  NINT         ctsemwat();
  1036. #ifdef ctSEMBLK
  1037. extern  NINT _lds_   ctblkrqs();
  1038. extern  NINT _lds_   ctblkclr();
  1039. extern  NINT         ctblkwat();
  1040. #endif
  1041. extern  NINT         ctdbw();
  1042. extern  NINT         ctdbr();
  1043. extern  NINT         ctlclose();
  1044. extern  COUNT        mbclos();
  1045. #ifdef ctMIRROR
  1046. extern  NINT         ctswtmir();
  1047. extern  COUNT        ctmirhdr();
  1048. extern  NINT         ctmname();
  1049. extern  NINT         ctmalert();
  1050. extern  COUNT        ctmopen();
  1051. extern  RNDFILE      ctopen();
  1052. extern  COUNT        ctmcreate();
  1053. extern  VOID         ctfrcmir();
  1054. #endif
  1055. extern  RNDFILE      mbopen();
  1056. extern  RNDFILE      mbcrat();
  1057. extern  COUNT        mbsave();
  1058. #ifndef ctsave
  1059. extern  COUNT        ctsave();
  1060. #endif
  1061. extern  VOID         flushdos();
  1062. extern  COUNT        filrng();
  1063. extern  COUNT        setimap();
  1064. #ifdef BIGCHECK
  1065. extern  NINT         CTCFILL();
  1066. #endif
  1067.  
  1068. #ifdef MULTITRD
  1069. extern  COUNT        INTREEz();
  1070. extern  COUNT        INTISAMz();
  1071. extern  COUNT        CREISAMz();
  1072. extern  COUNT        OPNISAMz();
  1073.  
  1074. extern  NINT         ctcnvfn();
  1075. static  NINT         dupopen();
  1076. extern  VOID         cttsus();
  1077. extern  NINT         ctloglog();
  1078. extern  NINT         ctclrsrvr();
  1079. extern  NINT         ctqcls();
  1080. extern  VOID         stopctsrvr();
  1081. extern  NINT         PIFlush();
  1082. extern  FarCmdPtr   *commCmds[MAXCOMMP];
  1083. extern  VOID         ctsetnmda();
  1084. extern  COUNT        ctugfil();
  1085. extern  COUNT        ctsetsec();
  1086. extern  COUNT        ctchksec();
  1087. extern  VOID         ctsetuginfo();
  1088. extern  NINT         ctismem();
  1089. extern  NINT         ctmemavl();
  1090. extern  NINT         blkcmtint();
  1091. extern  NINT         VDP();
  1092. extern  VOID         setcommbuf();
  1093. extern  VOID         ctdec();
  1094. extern  NINT         ctblksrvr();
  1095. extern  COUNT        srvrwait();
  1096. extern  VOID         initctsrvr();
  1097. extern  VOID         srvrcopyright();
  1098. extern  VOID         srvrflashmsg();
  1099. extern  VOID         ctenc();
  1100. extern  VOID         startctsrvr();
  1101. extern  NINT         ctclrclnt();
  1102. extern NINT ctkilblk();
  1103.  
  1104. #ifdef ___FNPglobals___
  1105. extern  Thread_     *makeThread();
  1106. extern  byte        *memory();
  1107. extern  VOID         delayDefer();
  1108. extern  VOID        *threadInit();
  1109. extern  VOID         killThread();
  1110. extern  int32        getThdTime();
  1111. extern  Thread_     *myThread();
  1112. extern  VOID         sleepThread();
  1113. extern  VOID         DEFER();
  1114. #endif /* ___FNPglobals___ */
  1115. #endif /* MULTITRD */
  1116.  
  1117. extern  VOID         ctidxfrsh();
  1118. extern COUNT chkidxhdr();
  1119.  
  1120. #ifdef TRANPROC
  1121. #ifdef SYNC_LOG
  1122. extern COUNT ctsync();
  1123. #endif
  1124. #endif
  1125.  
  1126. #ifdef ctSQL
  1127.  
  1128. NINT FlushLRU();
  1129. VOID login_auth();
  1130. VOID SetSQLTransactionMode();
  1131.  
  1132. #endif  /*  ctSQL  */
  1133.  
  1134. #endif /* pPROTOTYPE */
  1135.  
  1136. #endif /* ~ctFUNPH */
  1137.  
  1138. /* end of ctfunp.h */
  1139.